#include "file_system_model.h"
#include "database/file_system_status.h"
#include <QApplication>
#include <QFileInfo>
#include <QDir>
#include <QStorageInfo>
#include <QStandardPaths>
#include <QIcon>
#include <QFileIconProvider>
#include <QDebug>

FileSystemModel::FileSystemModel(DatabaseManager *databaseManager, QObject *parent)
    : QObject(parent)
    , m_databaseManager(databaseManager)
{
    // 设置当前路径为根目录
    m_currentPath = "/";
    
    if (m_databaseManager) {
        updateDrives();
        // 初始化当前目录文件列表
        m_currentDirectoryFiles = getDirectoryContents(m_currentPath, true); // 文件图标视图需要包含文件
    }
}

QString FileSystemModel::currentPath() const
{
    return m_currentPath;
}

void FileSystemModel::setCurrentPath(const QString &path)
{
    if (m_currentPath != path) {
        m_currentPath = path;
        updateCurrentDirectoryFiles();
        emit currentPathChanged();
    }
}

QVariantList FileSystemModel::drives() const
{
    return m_drives;
}

QStringList FileSystemModel::driveNames() const
{
    return m_driveNames;
}

void FileSystemModel::refresh()
{
    // updateDrives();
    
    // 触发路径变化信号以更新界面
    emit currentPathChanged();
}

bool FileSystemModel::isDirectory(const QString &path)
{
    if (!m_databaseManager) {
        return false;
    }
    
    // 检查是否为文件夹ID
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    for (const auto &folder : allFolders) {
        if (folder.id == path) {
            return true;  // 找到匹配的文件夹ID
        }
    }
    return false;  // 不是文件夹ID，则是文件
}

QString FileSystemModel::getFileName(const QString &path)
{
    if (!m_databaseManager) {
        return path;
    }
    
    qDebug() << "getFileName: 查找路径:" << path;
    
    // 检查是否为文件夹ID
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    qDebug() << "getFileName: 数据库中共有文件夹数量:" << allFolders.size();
    
    for (const auto &folder : allFolders) {
        if (folder.id == path) {
            qDebug() << "getFileName: 找到匹配的文件夹，ID:" << folder.id << "名称:" << folder.name;
            return folder.name;  // 返回文件夹名称
        }
    }
    
    // 如果不是文件夹ID，则检查是否为文件
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    qDebug() << "getFileName: 数据库中共有文件数量:" << allFiles.size();
    
    for (const auto &file : allFiles) {
        if (file.id == path) {
            qDebug() << "getFileName: 找到匹配的文件，ID:" << file.id << "名称:" << file.name;
            return file.name;  // 返回文件名称
        }
    }
    
    qDebug() << "getFileName: 未找到匹配的文件夹或文件，返回原始路径:" << path;
    return path;  // 如果都没找到，返回原始路径
}

QString FileSystemModel::getFileSize(const QString &path)
{
    if (!m_databaseManager) {
        return "未知";
    }
    
    // 检查是否为文件夹
    if (isDirectory(path)) {
        return "文件夹";
    }
    
    // 从数据库获取文件大小
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    for (const auto &file : allFiles) {
        if (file.id == path) {
            qint64 size = file.size;
            if (size < 1024) {
                return QString::number(size) + " B";
            } else if (size < 1024 * 1024) {
                return QString::number(size / 1024) + " KB";
            } else if (size < 1024 * 1024 * 1024) {
                return QString::number(size / (1024 * 1024)) + " MB";
            } else {
                return QString::number(size / (1024 * 1024 * 1024)) + " GB";
            }
        }
    }
    
    return "未知";
}

QString FileSystemModel::getFileType(const QString &path)
{
    QFileInfo info(path);
    if (info.isDir()) {
        return "文件夹";
    }
    
    QString suffix = info.suffix().toLower();
    if (suffix.isEmpty()) {
        return "文件";
    }
    
    // 常见文件类型映射
    QMap<QString, QString> typeMap;
    typeMap["txt"] = "文本文档";
    typeMap["doc"] = "Word 文档";
    typeMap["docx"] = "Word 文档";
    typeMap["pdf"] = "PDF 文档";
    typeMap["jpg"] = "JPEG 图像";
    typeMap["jpeg"] = "JPEG 图像";
    typeMap["png"] = "PNG 图像";
    typeMap["gif"] = "GIF 图像";
    typeMap["bmp"] = "BMP 图像";
    typeMap["mp3"] = "MP3 音频";
    typeMap["wav"] = "WAV 音频";
    typeMap["mp4"] = "MP4 视频";
    typeMap["avi"] = "AVI 视频";
    typeMap["zip"] = "ZIP 压缩包";
    typeMap["rar"] = "RAR 压缩包";
    typeMap["exe"] = "可执行文件";
    typeMap["dll"] = "动态链接库";
    
    return typeMap.value(suffix, suffix.toUpper() + " 文件");
}

QIcon FileSystemModel::getFileIcon(const QString &path)
{
    QFileIconProvider provider;
    QFileInfo info(path);
    return provider.icon(info);
}

QStringList FileSystemModel::getDirectoryContents(const QString &path, bool includeFiles)
{
    if (!m_databaseManager) {
        return QStringList();
    }
    
    return getDatabaseDirectoryContents(path, includeFiles);
}



QStringList FileSystemModel::getCurrentDirectoryFiles()
{
    return m_currentDirectoryFiles;
}

void FileSystemModel::updateCurrentDirectoryFiles()
{
    m_currentDirectoryFiles = getDirectoryContents(m_currentPath, true); // 文件图标视图需要包含文件
    emit currentDirectoryFilesChanged();
}

void FileSystemModel::updateDrives()
{
    m_drives.clear();
    m_driveNames.clear();
    
    if (m_databaseManager) {
        // 从数据库获取网盘列表
        QList<KmsDisk> disks = m_databaseManager->queryAllDisks();
        for (const auto &disk : disks) {
            QVariantMap diskMap;
            diskMap["id"] = disk.id;
            diskMap["name"] = disk.name;
            m_drives << diskMap;
            m_driveNames << disk.name;
        }
    }
    
    emit drivesChanged();
}

QStringList FileSystemModel::getDatabaseDirectoryContents(const QString &path, bool includeFiles)
{
    QStringList contents;
    
    if (!m_databaseManager) {
        qDebug() << "getDatabaseDirectoryContents: 数据库管理器为空";
        return contents;
    }
    
    qDebug() << "getDatabaseDirectoryContents: 处理路径:" << path << "包含文件:" << includeFiles;
    
    // 如果路径是根路径 "/"，返回当前网盘的顶级文件夹和文件
    if (path == "/") {
        // 获取顶级文件夹，过滤当前网盘
        QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
        qDebug() << "getDatabaseDirectoryContents: 获取到所有文件夹数量:" << allFolders.size() << "当前网盘ID:" << m_currentDiskId;
        
        for (const auto &folder : allFolders) {
            qDebug() << "getDatabaseDirectoryContents: 检查文件夹 ID:" << folder.id << "名称:" << folder.name << "父目录ID:" << folder.folderId << "网盘ID:" << folder.diskId;
            // 顶级文件夹的folder_id为空或者是根目录，且属于当前网盘
            if ((folder.folderId.isEmpty() || folder.folderId == "root") && 
                (m_currentDiskId.isEmpty() || folder.diskId == m_currentDiskId)) {
                contents << folder.id;
                qDebug() << "getDatabaseDirectoryContents: 添加顶级文件夹:" << folder.id;
            }
        }
        
        // 如果需要包含文件，获取根目录下的文件（FOLDER_ID为空或root的文件），过滤当前网盘
        if (includeFiles) {
            QList<KmsFile> rootFiles = m_databaseManager->queryFilesByFolderId("");
            QList<KmsFile> rootFiles2 = m_databaseManager->queryFilesByFolderId("root");
            rootFiles.append(rootFiles2);
            
            for (const auto &file : rootFiles) {
                // 只显示属于当前网盘的文件
                if (m_currentDiskId.isEmpty() || file.diskId == m_currentDiskId) {
                    contents << file.id;
                    qDebug() << "getDatabaseDirectoryContents: 添加根目录文件:" << file.id << "名称:" << file.name;
                }
            }
        }
    } else {
        // 根据父目录ID获取直接子目录
        contents = getDirectChildrenByParentId(path);
        qDebug() << "getDatabaseDirectoryContents: 获取子目录数量:" << contents.size();
        
        // 如果需要包含文件，获取该文件夹下的文件，过滤当前网盘
        if (includeFiles) {
            QList<KmsFile> folderFiles = m_databaseManager->queryFilesByFolderId(path);
            for (const auto &file : folderFiles) {
                // 只显示属于当前网盘的文件
                if (m_currentDiskId.isEmpty() || file.diskId == m_currentDiskId) {
                    contents << file.id;
                    qDebug() << "getDatabaseDirectoryContents: 添加文件:" << file.id << "名称:" << file.name;
                }
            }
        }
    }
    
    qDebug() << "getDatabaseDirectoryContents: 返回内容:" << contents;
    return contents;
}


QStringList FileSystemModel::getDirectChildrenByParentId(const QString &parentId)
{
    QStringList children;
    
    if (!m_databaseManager) {
        qDebug() << "getDirectChildrenByParentId: 数据库管理器为空";
        return children;
    }
    
    qDebug() << "getDirectChildrenByParentId: 查找父目录ID:" << parentId;
    
    // 获取所有文件夹
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    qDebug() << "getDirectChildrenByParentId: 获取到所有文件夹数量:" << allFolders.size();
    
    for (const auto &folder : allFolders) {
        qDebug() << "getDirectChildrenByParentId: 检查文件夹 ID:" << folder.id << "父目录ID:" << folder.folderId << "网盘ID:" << folder.diskId;
        if (folder.folderId == parentId && 
            (m_currentDiskId.isEmpty() || folder.diskId == m_currentDiskId)) {
            children << folder.id;
            qDebug() << "getDirectChildrenByParentId: 找到子目录:" << folder.id;
        }
    }
    
    qDebug() << "getDirectChildrenByParentId: 返回子目录数量:" << children.size();
    return children;
}


QStringList FileSystemModel::getDirectChildren(const QString &parentId)
{
    return getDirectChildrenByParentId(parentId);
}


QString FileSystemModel::getFolderName(const QString &folderId)
{
    if (!m_databaseManager) {
        return folderId;
    }
    
    // 获取所有文件夹
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    for (const auto &folder : allFolders) {
        if (folder.id == folderId) {
            return folder.name;
        }
    }
    
    return folderId; // 如果找不到，返回ID
}

int FileSystemModel::getFolderStatus(const QString &folderId)
{
    if (!m_databaseManager) {
        qDebug() << "getFolderStatus: 数据库管理器为空";
        return FileSystemStatus::PENDING_DOWNLOAD; // 默认状态：待下载
    }

    qDebug() << "getFolderStatus: 查找文件夹状态，ID:" << folderId;
    qDebug() << "getFolderStatus: 文件夹ID长度:" << folderId.length();
    qDebug() << "getFolderStatus: 文件夹ID是否为空:" << folderId.isEmpty();
    
    // 获取所有文件夹
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    qDebug() << "getFolderStatus: 数据库中共有文件夹数量:" << allFolders.size();
    
    for (int i = 0; i < allFolders.size(); ++i) {
        const auto &folder = allFolders[i];
        qDebug() << "getFolderStatus: 检查文件夹[" << i << "] ID:" << folder.id << "名称:" << folder.name << "状态:" << folder.status;
        if (folder.id == folderId) {
            qDebug() << "getFolderStatus: 找到匹配的文件夹，状态:" << folder.status;
            return folder.status;
        }
    }
    
    qDebug() << "getFolderStatus: 未找到文件夹，返回默认状态" << FileSystemStatus::PENDING_DOWNLOAD;
    return FileSystemStatus::PENDING_DOWNLOAD; // 默认状态：待下载
}

int FileSystemModel::getFolderType(const QString &folderId)
{
    if (!m_databaseManager) {
        qDebug() << "getFolderType: 数据库管理器为空";
        return 0; // 默认类型：0
    }

    qDebug() << "getFolderType: 查找文件夹类型，ID:" << folderId;
    
    // 获取所有文件夹
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    qDebug() << "getFolderType: 数据库中共有文件夹数量:" << allFolders.size();
    
    for (int i = 0; i < allFolders.size(); ++i) {
        const auto &folder = allFolders[i];
        if (folder.id == folderId) {
            qDebug() << "getFolderType: 找到匹配的文件夹，类型:" << folder.type;
            return folder.type;
        }
    }
    
    qDebug() << "getFolderType: 未找到文件夹，返回默认类型 0";
    return 0; // 默认类型：0
}

QString FileSystemModel::getFolderDiskId(const QString &folderId)
{
    if (!m_databaseManager) {
        qDebug() << "getFolderDiskId: 数据库管理器为空";
        return QString(); // 返回空字符串
    }

    qDebug() << "getFolderDiskId: 查找文件夹的网盘ID，文件夹ID:" << folderId;
    
    // 获取所有文件夹
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    qDebug() << "getFolderDiskId: 数据库中共有文件夹数量:" << allFolders.size();
    
    for (int i = 0; i < allFolders.size(); ++i) {
        const auto &folder = allFolders[i];
        if (folder.id == folderId) {
            qDebug() << "getFolderDiskId: 找到匹配的文件夹，网盘ID:" << folder.diskId;
            return folder.diskId;
        }
    }
    
    qDebug() << "getFolderDiskId: 未找到文件夹，返回空字符串";
    return QString(); // 如果找不到，返回空字符串
}

QString FileSystemModel::getFileFolderPath(const QString &fileId)
{
    if (!m_databaseManager) {
        qDebug() << "getFileFolderPath: 数据库管理器为空";
        return QString(); // 返回空字符串
    }

    qDebug() << "getFileFolderPath: 查找文件的文件夹路径，文件ID:" << fileId;
    
    // 获取所有文件
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    qDebug() << "getFileFolderPath: 数据库中共有文件数量:" << allFiles.size();
    
    QString folderId;
    for (int i = 0; i < allFiles.size(); ++i) {
        const auto &file = allFiles[i];
        if (file.id == fileId) {
            folderId = file.folderId;
            qDebug() << "getFileFolderPath: 找到匹配的文件，文件夹ID:" << folderId;
            break;
        }
    }
    
    // 如果没有找到文件或文件夹ID为空，返回空字符串
    if (folderId.isEmpty()) {
        qDebug() << "getFileFolderPath: 未找到文件或文件夹ID为空";
        return QString();
    }
    
    // 获取所有文件夹
    QList<KmsFolder> allFolders = m_databaseManager->queryAllFolders();
    qDebug() << "getFileFolderPath: 数据库中共有文件夹数量:" << allFolders.size();
    
    for (int i = 0; i < allFolders.size(); ++i) {
        const auto &folder = allFolders[i];
        if (folder.id == folderId) {
            qDebug() << "getFileFolderPath: 找到匹配的文件夹，路径:" << folder.path;
            return folder.path;
        }
    }
    
    qDebug() << "getFileFolderPath: 未找到文件夹，返回空字符串";
    return QString(); // 如果找不到，返回空字符串
}

int FileSystemModel::getFileStatus(const QString &fileId)
{
    if (!m_databaseManager) {
        qDebug() << "getFileStatus: 数据库管理器为空";
        return 0; // 默认状态：未同步
    }

    qDebug() << "getFileStatus: 查找文件状态，ID:" << fileId;
    qDebug() << "getFileStatus: 文件ID长度:" << fileId.length();
    qDebug() << "getFileStatus: 文件ID是否为空:" << fileId.isEmpty();
    
    // 获取所有文件
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    qDebug() << "getFileStatus: 数据库中共有文件数量:" << allFiles.size();
    
    for (int i = 0; i < allFiles.size(); ++i) {
        const auto &file = allFiles[i];
        qDebug() << "getFileStatus: 检查文件[" << i << "] ID:" << file.id << "名称:" << file.name << "状态:" << file.status;
        if (file.id == fileId) {
            qDebug() << "getFileStatus: 找到匹配的文件，状态:" << file.status;
            return file.status;
        }
    }
    
    qDebug() << "getFileStatus: 未找到文件，返回默认状态 0";
    return 0; // 默认状态：未同步
}

QString FileSystemModel::getDiskIdByName(const QString &diskName)
{
    if (!m_databaseManager) {
        qDebug() << "getDiskIdByName: 数据库管理器为空";
        return diskName; // 如果数据库不可用，返回名称作为ID
    }
    
    QList<KmsDisk> allDisks = m_databaseManager->queryAllDisks();
    for (const auto &disk : allDisks) {
        if (disk.name == diskName) {
            qDebug() << "getDiskIdByName: 找到网盘，名称:" << diskName << "ID:" << disk.id;
            return disk.id;
        }
    }
    
    qDebug() << "getDiskIdByName: 未找到网盘，名称:" << diskName;
    return diskName; // 如果找不到，返回名称
}

QString FileSystemModel::getDiskNameById(const QString &diskId)
{
    if (!m_databaseManager) {
        qDebug() << "getDiskNameById: 数据库管理器为空";
        return diskId; // 如果数据库不可用，返回ID作为名称
    }
    
    QList<KmsDisk> allDisks = m_databaseManager->queryAllDisks();
    for (const auto &disk : allDisks) {
        if (disk.id == diskId) {
            qDebug() << "getDiskNameById: 找到网盘，ID:" << diskId << "名称:" << disk.name;
            return disk.name;
        }
    }
    
    qDebug() << "getDiskNameById: 未找到网盘，ID:" << diskId;
    return diskId; // 如果找不到，返回ID
}

QVariantList FileSystemModel::getAllDisks()
{
    QVariantList diskList;
    
    if (!m_databaseManager) {
        qDebug() << "getAllDisks: 数据库管理器为空";
        return diskList;
    }
    
    QList<KmsDisk> allDisks = m_databaseManager->queryAllDisks();
    qDebug() << "getAllDisks: 获取到网盘数量:" << allDisks.size();
    
    for (const auto &disk : allDisks) {
        QVariantMap diskMap;
        diskMap["id"] = disk.id;
        diskMap["name"] = disk.name;
        diskMap["type"] = disk.type;
        diskMap["domainId"] = disk.domainId;
        diskMap["ownerId"] = disk.ownerId;
        diskMap["orderNo"] = disk.orderNo;
        diskList.append(diskMap);
        
        qDebug() << "getAllDisks: 添加网盘 - ID:" << disk.id << "名称:" << disk.name;
    }
    
    return diskList;
}

void FileSystemModel::setCurrentDisk(const QString &diskId)
{
    if (m_currentDiskId != diskId) {
        m_currentDiskId = diskId;
        qDebug() << "setCurrentDisk: 设置当前网盘ID为:" << diskId;
        
        // 当切换网盘时，重置当前路径到根目录
        setCurrentPath("/");
        
        // 刷新目录内容
        updateCurrentDirectoryFiles();
    }
}

QString FileSystemModel::getCurrentDiskId()
{
    return m_currentDiskId;
}

QString FileSystemModel::getFileUrl(const QString &fileId)
{
    // 注意：URL字段已移除，此方法已废弃，返回空字符串
    qDebug() << "警告：getFileUrl方法已废弃（URL字段已移除），文件ID:" << fileId;
    return QString();
}

qint64 FileSystemModel::getLocalFileSize(const QString &fileId)
{
    if (!m_databaseManager) {
        qDebug() << "getLocalFileSize: 数据库管理器为空";
        return 0;
    }
    
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    for (const auto &file : allFiles) {
        if (file.id == fileId) {
            qDebug() << "getLocalFileSize: 找到本地文件大小:" << file.localFileSize << "文件ID:" << fileId;
            return file.localFileSize;
        }
    }
    
    qDebug() << "getLocalFileSize: 未找到文件ID:" << fileId;
    return 0;
}

QString FileSystemModel::getLocalFileChecksum(const QString &fileId)
{
    if (!m_databaseManager) {
        qDebug() << "getLocalFileChecksum: 数据库管理器为空";
        return QString();
    }
    
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    for (const auto &file : allFiles) {
        if (file.id == fileId) {
            qDebug() << "getLocalFileChecksum: 找到本地文件校验和:" << file.localFileChecksum << "文件ID:" << fileId;
            return file.localFileChecksum;
        }
    }
    
    qDebug() << "getLocalFileChecksum: 未找到文件ID:" << fileId;
    return QString();
}

QString FileSystemModel::getLocalFilePath(const QString &fileId)
{
    if (!m_databaseManager) {
        qDebug() << "getLocalFilePath: 数据库管理器为空";
        return QString();
    }
    
    QList<KmsFile> allFiles = m_databaseManager->queryAllFiles();
    for (const auto &file : allFiles) {
        if (file.id == fileId) {
            qDebug() << "getLocalFilePath: 找到本地文件路径:" << file.localFilePath << "文件ID:" << fileId;
            return file.localFilePath;
        }
    }
    
    qDebug() << "getLocalFilePath: 未找到文件ID:" << fileId;
    return QString();
}

bool FileSystemModel::canGoUp(const QString &folderId)
{
    if (folderId.isEmpty() || !m_databaseManager) {
        return false;
    }
    
    // 如果folderId是根路径"/"，返回false
    if (folderId == "/") {
        return false;
    }
    
    // 查询文件夹信息
    KmsFolder folder = m_databaseManager->queryFolderById(folderId);
    
    // 检查是否存在父文件夹
    // folderId字段为空或"root"表示顶级文件夹，不能向上导航
    if (folder.id.isEmpty() || folder.folderId.isEmpty() || folder.folderId == "root") {
        return false;
    }
    
    return true;
}

QString FileSystemModel::getParentPath(const QString &folderId)
{
    if (folderId.isEmpty() || !m_databaseManager) {
        return "";
    }
    
    // 如果folderId是根路径"/"，返回空字符串
    if (folderId == "/") {
        return "";
    }
    
    // 查询文件夹信息
    KmsFolder folder = m_databaseManager->queryFolderById(folderId);
    
    // 如果找不到文件夹，返回空字符串
    if (folder.id.isEmpty()) {
        return "";
    }
    
    // 如果父文件夹ID为空或"root"，返回根路径"/"
    if (folder.folderId.isEmpty() || folder.folderId == "root") {
        return "/";
    }
    
    // 返回父文件夹ID
    return folder.folderId;
}